package com.linewell.license.demo.thread;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;

/**
 * @Title: license-215
 * @description: 多线程使用测试。
 * @author: hyuhuang@linewell.com
 * @since:2018/8/29
 */
public class Thread {
    static int count = 0;
    static AtomicLong count1 = new AtomicLong();
    /**
     * 创建固定大小的线程池 线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程
     */
    static ExecutorService executor = Executors.newFixedThreadPool(100);//创建线程池大小为100个线程的线程池
    /**
     *  创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求
     */
    static ExecutorService executor1 = Executors.newSingleThreadScheduledExecutor();
    /**
     * 创建一个单线程的线程池。这个线程池只有线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，
     * 那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行
     */
    static ExecutorService executor2 = Executors.newSingleThreadExecutor();
    /**
     * 创建一个可缓存的线程池，如果线程池的大小超过了处理任务所需要的线程，
     * 那么就会回收部分空闲(60s不执行任务)的线程，当任务数量增加时，此线程池又可以智能的添加新线程来处理任务。
     * 此线程池不会对线程池大小做限制，线程池大小完全依赖于系统（JVM）能够创建的最大线程大小
     */
    static ExecutorService executor3 = Executors.newCachedThreadPool();
    /**
     *  创建一个大小无限的线程池，此线程池支持定时以及周期性执行任务的需求
     */
    static ExecutorService executor4 = Executors.newScheduledThreadPool(0);
    static CountDownLatch latch = new CountDownLatch(100);   //计数，计算线程执行结束的计数器。当执行一个线程后，就计算一个线程任务结束了。
    static List<Future> list = new ArrayList<>();
    static Semaphore semaphore = new Semaphore(5);

    @Test
    public void Test() throws InterruptedException {
        for (int i = 0; i < 100; i++) {
//                synchronized (executor) {    //对线程进行加锁
            executor.execute(() -> {    //execute  没有返回值。
                for (int j = 0; j < 10000; j++) {
                    count++;
                    count1.incrementAndGet();    //线程安全计数
                }
                latch.countDown();   //类似于计数器。每次减一次的操作。
            });
//                }
        }
        latch.await();    //等待所有线程任务结束。
        executor.shutdownNow();  //关闭线程池
        System.out.println(count);
        System.out.println(count1.get());

    }

    /**
     * Future 的get() 是得到任务结束后的返回值。当执行了100个任务。就需要100个get()来执行等待结束的时间。
     *
     * @throws Exception
     */
    @Test
    public void Test3() throws Exception {
        for (int i = 0; i < 100; i++) {
            Future future = executor.submit(() -> {    //submit 会返回一个future，可以根据future来解决其他东西。
                for (int j = 0; j < 10000; j++) {
                    count++;
                    count1.incrementAndGet();
                }
            });
            list.add(future);
        }
        for (Future f : list) {
            f.get();
        }
        executor.shutdownNow();
        System.out.println(count);
        System.out.println(count1.get());
    }


    /**
     * @throws Exception
     */
    @Test
    public void Test4() throws Exception {
        ExecutorCompletionService executorCompletionService = new ExecutorCompletionService(executor);
        for (int i = 0; i < 100; i++) {
            executorCompletionService.submit(() -> {
                for (int j = 0; j < 10000; j++) {
                    count++;
                    count1.incrementAndGet();
                }
                return null;
            });
        }
        for (int i = 0; i < 100; i++) {
            executorCompletionService.take().get();   //拿到上面返回的null
        }
        executor.shutdownNow();
        System.out.println(count);
        System.out.println(count1.get());
    }


    @Test
    public void Test5() throws Exception {
        BlockingQueue blockingQueue = new LinkedBlockingQueue();
        for (int i = 0; i < 100; i++) {
            executor.execute(() -> {
                for (int j = 0; j < 10000; j++) {
                    count++;
                    count1.incrementAndGet();
                }
                blockingQueue.offer("");//offer 放入
            });
        }
        for (int i = 0; i < 100; i++) {
            blockingQueue.take();  // take 当线程任务执行完了，offer放入的值就可以取出了。
        }
        executor.shutdownNow();
        System.out.println(count);
        System.out.println(count1.get());
    }


    @Test
    public void Test2() throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(100);
        for (int i = 0; i < 100; i++) {
            executor.execute(() -> {
                for (int j = 0; j < 10000; j++) {
                    count++;
                }
            });
        }
        executor.shutdownNow();
        System.out.println(count);
    }

    //信号量锁定线程。
    @Test
    public void semaphore() {
        for (int i = 0; i < 100; i++) {
            //可用的线程数量是否大于0个
            if (semaphore.availablePermits() > 0) {
                executor.execute(() -> {
                    try {
                        //占用许可
                        semaphore.acquire();
                        for (int j = 0; j < 10000; j++) {
                            count++;
                            System.out.println(count);
                        }
                        //释放许可
                        semaphore.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                });
            }
        }
        executor.shutdownNow();
        System.out.println(count);

    }
}
